<?php

//Inclure la class d'accès à la base de données
include_once '../../DBAccess/DBAccess.php';

class AlgoWall {

    public $te; //Température extérieure
    public $ti; //Température ambiante inrérieure
    public $textra; //Extrapolation - supplément de régulation
    public $cst = 365; //Durée de la période de calcul
    public $wallSurface; //Surface nette des murs
    public $wallCoeficient; //Coéficient des murs
    public $sre; //Surface de référence énergétique SRE
    public $factReductNC = 1; // Facteur de réduction pour les murs (locaux non chauffés)
    public $factReductT = 1; // Facteur de réduction pour les murs (terrain)
    //public $tempLC = 20; // Température ambiante du local contigu (par défaut)

    public $totalSurfaceWindows; //Surface totale des fenêtes
    public $totalSurface; //Surface total de la maison (m2)
    //public $factCorrSRE = 4; // Facteur correcteur SRE
    public $totalSurfaceNC; // Surface totale des murs (locaux non chauffés)
    public $totalSurfaceAE; // Surface totale des murs (Air extérieur)
    public $totalSurfaceT; // Surface totale des murs (terrain)
    public $totalSurfaceLC; // Surface totale des murs (locaux contigus)
    public $CoefNC = array(); // Coéficient U murs (locaux non chauffés)
    public $CoefAE = array(); // Coéficient U murs (Air extérieur)
    public $CoefT = array(); // Coéficient U murs (terrain)
    public $CoefLC = array(); // Coéficient U murs (locaux contigus)
    public $totalCoefNC; //Moyenne coéficient (locaux non chauffés)
    public $totalCoefAE; //Moyenne coéficient (Air extérieur)
    public $totalCoefT; //Moyenne coéficient (terrain)
    public $totalCoefLC; //Moyenne coéficient (locaux contigus)
    public $deperditionNC; // Déperdition pour les murs (locaux non chauffés)
    public $deperditionAE; // Déperdition pour les murs (Air extérieur)
    public $deperditionT; // Déperdition pour les murs (terrain)
    public $deperditionLC; // Déperdition pour les murs (locaux contigus)
    public $totalDeperdition; //Déperdition totales de tous les murs

//Retourne la valeur U d'un mûr selon la continuité, l'année de construction et les différentes couches si connues

    function getValeurU_Mur($wall, $year) {

        $valeurU;
        $Rtherm;

        if (empty($wall->layers)) {
            switch ($wall->continuity) {
                //Murs contre locaux non chauffés
                case 2:
                    if (empty($wall->year)) {
                        $valeurU = DBAccess::getValeurU_NC($year);
                    } else {
                        $valeurU = DBAccess::getValeurU_NC($wall->year);
                    }
                    break;
                //Murs exposés à l'air extérieur
                case 1:
                    if (empty($wall->year)) {
                        $valeurU = DBAccess::getValeurU_AE_LC($year);
                    } else {
                        $valeurU = DBAccess::getValeurU_AE_LC($wall->year);
                    }

                    break;
                //Murs en contact avec le terrain
                case 4:
                    if (empty($wall->year)) {
                        $valeurU = DBAccess::getValeurU_T($year);
                    } else {
                        $valeurU = DBAccess::getValeurU_T($wall->year);
                    }

                    break;
                //Murs contre locaux contigus
                case 3:
                    if (empty($wall->year)) {
                        $valeurU = DBAccess::getValeurU_AE_LC($year);
                    } else {
                        $valeurU = DBAccess::getValeurU_AE_LC($wall->year);
                    }

                    break;

                default :
                    echo 'Continuite non connue....';
                    break;
            }
        } else {
            //passer en parametre un tableau de couches (ex: {bois, 35cm}, {verre, 25cm})
            $Rtherm = getRtherm($wall->layers);


            if ($wall->continuity == 1)
                $valeurU = 1 / (0.17 + $Rtherm);
            else
                $valeurU = 1 / (0.22 + $Rtherm);
        }

        return $valeurU;
    }

//calcul la valeur Rtherm pour toutes les couches présentes
    function getRtherm($couches) {

        $Rtherm = 0;

        //Parcours toutes les couches et aditionne les valeurs Rtherm
        foreach ($couches as $value) {

            $Rtherm += $value[0] / 100 / DBAccess::getRthermMat("'" . utf8_decode($value[1]) . "'"); //récupération dans la BD
        }
        return $Rtherm;
    }

// Calcul de la déperdition totale selon la continuité des murs
// Retourne la déperdition totale de tous les murs
    function getTotalDeperdition($house) {

        // Parcours de tous les murs et calculs selon la continuité
        foreach ($house->walls as $wall) {

            switch ($wall->continuity) {

                case 2:
                    $this->totalSurfaceNC += $wall->surface; //addition des surface nette des murs (locaux non chauffés)
                    array_push($this->CoefNC, $this->getCoefNC($wall, $house->year)); // stockage des coéficient des murs (locaux non chauffés)
                    break;

                case 1:
                    $this->totalSurfaceAE += $wall->surface; //addition des surface nette des murs (Air extérieur)
                    array_push($this->CoefAE, $this->getCoefAE($wall, $house->year)); // stockage des coéficient des murs (Air extérieur)
                    break;

                case 4:
                    $this->totalSurfaceT += $wall->surface; //addition des surface nette des murs (terrain)
                    array_push($this->CoefT, $this->getCoefT($wall, $house->year)); // stockage des coéficient des murs (terrain)
                    break;

                case 3:
                    $this->totalSurfaceLC += $wall->surface; //addition des surface nette des murs (locaux contigus)
                    array_push($this->CoefLC, $this->getCoefLC($wall, $house->year)); // stockage des coéficient des murs (locaux contigus)
                    break;

                default :
                    echo 'Continuite non connues....';
                    break;
            }
        }

        //Récupération de la surface totale des fenêtres
        $this->totalSurfaceWindows = $this->getTotalSurfaceWindows($house->walls);
        
        //Soustraction de la surface totale des fenêtres
        $this->totalSurfaceAE -= $this->totalSurfaceWindows;

        //Récupération de la température extérieure selon la ville de résidence
        $this->te = DBAccess::getExTemp($house->idCity);
        
         //Récupération du supplément de régulation pour la température ambiante
        $this->textra = DBAccess::getTempExtrapolation($house->year);
        //Température exemple
        $this->ti = $house->roomsTemp;
        $this->ti = $this->ti + $this->textra;
        


        //Calcul des coéficients U des murs (locaux contigus)
        if (!empty($this->CoefLC))
            $this->totalCoefLC = array_sum($this->CoefLC) / count($this->CoefLC);

        //Calcul des coéficients U des murs (locaux non chauffés)
        if (!empty($this->CoefNC))
            $this->totalCoefNC = array_sum($this->CoefNC) / count($this->CoefNC);

        //Calcul des coéficients U des murs (Air extérieur)
        if (!empty($this->CoefAE))
            $this->totalCoefAE = array_sum($this->CoefAE) / count($this->CoefAE);

        //Calcul des coéficients U des murs (terrain)
        if (!empty($this->CoefT))
            $this->totalCoefT = array_sum($this->CoefT) / count($this->CoefT);


        //Calcul de la surface de référence énergétique (SRE)
        $this->sre = $this->getSRE($house);
        
        // Calcul de la déperdition pour les murs (locaux non chauffés)
        $this->deperditionNC = ($this->ti - $this->te) * $this->cst * $this->totalSurfaceNC * $this->totalCoefNC * $this->factReductNC * 86400 / (1000000 * $this->sre);

        // Calcul de la déperdition pour les murs (Air extérieur)
        $this->deperditionAE = ($this->ti - $this->te) * $this->cst * $this->totalSurfaceAE * $this->totalCoefAE * 86400 / (1000000 * $this->sre);

        // Calcul de la déperdition pour les murs (terrain)
        $this->deperditionT = ($this->ti - $this->te) * $this->cst * $this->totalSurfaceT * $this->totalCoefT * $this->factReductT * 86400 / (1000000 * $this->sre);

        // Calcul de la déperdition pour les murs (locaux contigus)
        $this->deperditionLC = ($this->ti - $this->te) * $this->cst * $this->totalSurfaceLC * $this->totalCoefLC * 86400 / (1000000 * $this->sre);

        //Additon des déperditions
        $this->totalDeperdition = $this->deperditionAE + $this->deperditionLC + $this->deperditionNC + $this->deperditionT;

        return $this->totalDeperdition;
    }

    //Récupération et calcul de la surface totale des fenêtres
    function getTotalSurfaceWindows($walls){
        foreach ($walls as $wall) {
            foreach ($wall->windows as $window) {
                
                $this->totalSurfaceWindows += ($window->l1 * $window->l2);
            }
            
        }
        
        return $this->totalSurfaceWindows;
    }

    
    //Fonctions pour le calcul du coeficient U des murs selon la continuité
    function getCoefNC($wall, $year) {
        return $this->getValeurU_Mur($wall, $year);
    }

    function getCoefAE($wall, $year) {
        return $this->getValeurU_Mur($wall, $year);
    }

    function getCoefT($wall, $year) {
        return $this->getValeurU_Mur($wall, $year);
    }

    function getCoefLC($wall, $year) {
        return $this->getValeurU_Mur($wall, $year);
    }

    //Fonction pour le calcul de la surface de référence énergétique (SRE)
    function getSRE($house) {
        switch ($house->idShape) {
            // Forme carré et rectangle
            case 1:
                $this->totalSurface = $house->M1 * $house->M1 * $house->floors;
                break;
            case 2:
                $this->totalSurface = $house->M1 * $house->M2;
                $this->totalSurface *= $house->floors;

                break;
            //Forme en L
            case 3:
                $this->totalSurface = ($house->M1 * $house->M4) + ($house->M2 - $house->M4) * $house->M3;
                $this->totalSurface *= $house->floors;
                break;
            //Forme en U
            case 4:
                $this->totalSurface = ($house->M1 * $house->M6) + ($house->M4 * $house->M5) + ($house->M2 - $house->M6) * $house->M3;
                $this->totalSurface *= $house->floors;
                break;
            //Forme rect. décalé
            case 5:
               $this->totalSurface = ($house->M1 * $house->M2) + $house->M6 * ($house->M7 - $house->M4) + ($house->M4 * $house->M5);
                $this->totalSurface *= $house->floors;
                break;
            //Forme en T
             case 6:
                $this->totalSurface = ($house->M1 * $house->M2) + ($house->M4 * $house->M5);
                $this->totalSurface *= $house->floors;
                break;
            
            default :
                echo 'Forme de la maison non connue....';
                break;
        }

        return $this->totalSurface;
    }

}
?>